'use strict';
// 通过 require 引入 vk 实例
const vk = require('vk-unicloud');
// 通过 vk.init 初始化 vk实例（只有初始化后才能使用）
vk.init({
	baseDir: __dirname,
	requireFn: require
});

exports.main = async (event, context) => {
	const db = uniCloud.database();
	const _ = db.command;
	var res = {
		code: 0,
		msg: ""
	};
	
	//=============
	// console.log("event=",event);
	
	// return res;
	//=============

	var time = vk.pubfn.getCommonTime(new Date());
	var todayStart = time.todayStart;
	var todayEnd = time.todayEnd;
	//昨日开始时间 = 今日开始时间减86400000（24小时）
	// var last_StartTime = todayStart;
	// var last_EndTime = todayEnd;
	var last_StartTime = todayStart - 86400000
	var last_EndTime = todayStart - 1 //昨日结束时间
	var yesterday = vk.pubfn.timeFormat(last_StartTime, "yyyy-MM-dd");

	/**
	 * auto_run云函数从00:05分开始，每隔10分钟执行一次
	 * 因此第一次执行时间为00:05,此时hour=0且minute小于10，执行初始化函数
	 * 初始化函数把全部的投放链接和机构账号、代理商账号、admin账号的isComputed参数初始化为0.代表当日数据未进行自动计算
	 * package.json里的config配置参考：0 5/10 0-6 * * * * （代表从0点5分开始，每十分钟执行一次，执行时间是每天的0点到6点）
	 */


	if (time.now.hour == 0 && time.now.minute < 10) {
		await initAll()
		return res;
	}


	//====计算平台级数据,如已存在则不继续添加====
	let yesterday_data = await db.collection('a_datas').where({
		date: yesterday,
		type: 0 //0为平台级数据，1为代理商级别数据，2为投放链接级别数据 3为机构账号级别数据
	}).count()

	console.log("total=", yesterday_data.total);
	if (yesterday_data.total == 0) {
		// 云函数内调用其他云函数或云对象内的函数,进行数据统计。
		let callRes = await vk.callFunction({
			name: "hedian",
			url: 'admin/auto_run/pub/compute_all_data',
			data: {
				todayStart,
				todayEnd,
				last_StartTime,
				last_EndTime,
				yesterday
			},
		});
	} else {
		console.log("平台数据已计算,本次不再重复执行");
	}
	//====计算平台级数据结束====



	//中间人
	let middlemans = await db.collection('uni-id-users').where({
		role: _.in(["middleman"]),
		isComputed: 0
	}).limit(10).get()
	console.log("本次查询的机构数量=", middlemans.data.length);

	//当存在未计算的机构账号时，才执行以下逻辑
	if (middlemans.data.length > 0) {
		let batchRun_middleman = await vk.pubfn.batchRun({
			// 批量执行函数
			main: async (item, index) => {
				await vk.pubfn.sleep((Math.floor(Math.random() * (3 - 0)) + 0) * 100);
				await vk.callFunction({
					name: "hedian",
					url: 'admin/auto_run/pub/compute_middleman_data',
					data: {
						user_id: item._id,
						item,
						todayStart,
						todayEnd,
						last_StartTime,
						last_EndTime,
						yesterday
					}
				});
				return {
					code: 0,
					index
				}
			},
			concurrency: 5, // 最大并发量，如果设置为1，则会按顺序执行
			data: middlemans.data // 数据源，这些数据会依次跑一遍main函数，相当于for循环里的数组
		});
	} else {
		console.log("不存在未计算的机构账号");
	}



	//代理商
	let agents = await db.collection('uni-id-users').where({
		role: _.in(["agent"]),
		isComputed: 0
	}).limit(30).get()
	console.log("本次查询的代理商数量=", agents.data.length);

	//当存在未计算的代理商账号时，才执行以下逻辑
	if (agents.data.length > 0) {
		let batchRun_agents = await vk.pubfn.batchRun({
			// 批量执行函数
			main: async (item, index) => {
				await vk.pubfn.sleep((Math.floor(Math.random() * (3 - 0)) + 0) * 100);
				await vk.callFunction({
					name: "hedian",
					url: 'admin/auto_run/pub/compute_agent_data',
					data: {
						user_id: item._id,
						item,
						todayStart,
						todayEnd,
						last_StartTime,
						last_EndTime,
						yesterday
					}
				});
				return {
					code: 0,
					index
				}
			},
			concurrency: 5, // 最大并发量，如果设置为1，则会按顺序执行
			data: agents.data // 数据源，这些数据会依次跑一遍main函数，相当于for循环里的数组
		});
	} else {
		console.log("不存在未计算的代理商账号");
	}

	//====计算每个代理商的数据结束====


	//====计算每条投放链接的数据====
	let tfurls = await db.collection('a_dy_tfurl').where({
		isComputed: 0
	}).orderBy('agentId', 'desc').limit(100).get()
	console.log("本次查询的投放链接数量=", tfurls.data.length);

	//当存在未计算的投放链接时，才执行以下逻辑
	if (tfurls.data.length > 0) {
		let batchRun_tfurl = await vk.pubfn.batchRun({
			main: async (item, index) => {
				await vk.pubfn.sleep((Math.floor(Math.random() * (3 - 0)) + 0) * 100);
				await vk.callFunction({
					name: "hedian",
					url: 'admin/auto_run/pub/compute_tfurl_data',
					data: {
						tfid: item._id,
						item,
						todayStart,
						todayEnd,
						last_StartTime,
						last_EndTime,
						yesterday
					}
				});
				return {
					code: 0,
					index
				}
			},
			concurrency: 5,
			data: tfurls.data
		});
	} else {
		console.log("不存在未计算的投放链接");
	}

	//====计算每条投放链接的数据结束====

	let adds = await db.collection('vk-test').add({
		name: "已触发定时执行",
		time: new Date().getTime(),
		time_str: vk.pubfn.timeFormat(new Date(), "yyyy-MM-dd hh:mm:ss")
	})

	return res;

	//自定义函数开始
	async function initAll() {
		// 返回被修改的记录条数
		let init_user = await vk.baseDao.update({
			dbName: "uni-id-users", // 表名
			whereJson: { // 条件
				role: _.exists(true), // true：存在 false：不存在
			},
			dataJson: { // 需要修改的数据
				isComputed: 0, //当天是否已经计算，0没有计算，1已经计算
			}
		});
		console.log("初始化init_user=", init_user);


		// 返回被修改的记录条数
		let init_tfurl = await vk.baseDao.update({
			dbName: "a_dy_tfurl", // 表名
			whereJson: { // 条件
				_id: _.exists(true), // true：存在 false：不存在
			},
			dataJson: { // 需要修改的数据
				isComputed: 0, //当天是否已经计算，0没有计算，1已经计算
			}
		});
		console.log("初始化init_tfurl=", init_tfurl);
	}
	//自定义函数结束

};
